// Package imports:
import 'package:drift/drift.dart' as drift;
import 'package:drift/drift.dart';
import 'package:get/get.dart';

// Project imports:
import 'package:palmf_hid/common/entities/data_base/my_database.dart';
import 'package:palmf_hid/common/entities/data_base/my_plamf_entity.dart';
import 'package:palmf_hid/common/utils/my_log_util.dart';

class DbService extends GetxService {
  static DbService get to => Get.find();
  late final MyDatabase _dbService;

  Future<DbService> init() async {
    _dbService = MyDatabase();
    return this;
  }

  // 加载所有的 MyPalmF 实体
  Future<List<MyPalmF>> get allMyPalmFEntries =>
      _dbService.select(_dbService.myPalmFEntity).get();

  // 加载所有的 手持机 实体
  Future<List<MyPalmF>> allMyPalmFDeviceEntries(int type) {
    return (_dbService.select(_dbService.myPalmFEntity)
          ..where((tbl) {
            //设备类型 0 手持机 1 PC
            return tbl.type.isValue(type);
          }))
        .get();
  }

  // 查询所有测试结果记录条数
  Future<List<Results>> allResultDataCountByDeviceNoOrProject(
      String deviceNo, String projectName, String checkTime) {
    var result = (_dbService.select(_dbService.resultEntity)
          ..where((tbl) {
            if (checkTime == "") {
              return tbl.deviceNo.like('%$deviceNo%') &
                  tbl.projectName.like('%$projectName%');
            } else {
              return tbl.deviceNo.like('%$deviceNo%') &
                  tbl.projectName.like('%$projectName%') &
                  tbl.time.isBiggerOrEqualValue(
                      DateTime.parse("$checkTime 00:00:00")) &
                  tbl.time.isSmallerOrEqualValue(
                      DateTime.parse("$checkTime 23:59:59"));
            }
          }))
        .get();
    return result;
  }

  // 查询所有测试结果记录
  Future<List<Results>> allResultDataByDeviceNoOrProject(
      String deviceNo, String projectName, String checkTime) {
    return (_dbService.select(_dbService.resultEntity)
          ..orderBy([
            (u) => OrderingTerm(expression: u.time, mode: OrderingMode.desc)
          ])
          ..where((tbl) {
            if (checkTime == "") {
              return tbl.deviceNo.like('%$deviceNo%') &
                  tbl.projectName.like('%$projectName%');
            } else {
              return tbl.deviceNo.like('%$deviceNo%') &
                  tbl.projectName.like('%$projectName%') &
                  tbl.time.isBiggerOrEqualValue(
                      DateTime.parse("$checkTime 00:00:00")) &
                  tbl.time.isSmallerOrEqualValue(
                      DateTime.parse("$checkTime 23:59:59"));
            }
          }))
        .get();
  }

  // 根据过滤查询所有宠物信息
  Future<List<PetInfo>> allPetInfoByScreen(String petName, String masterName) {
    return (_dbService.select(_dbService.petInfoEntity)
          ..where((tbl) {
            return tbl.petName.like('%$petName%') &
                tbl.masterName.like('%$masterName%');
          }))
        .get();
  }

// 添加手持机蓝牙信息缓存到数据库
  Future<int> addPetInfo(PetInfoEntityCompanion entry) {
    return _dbService.into(_dbService.petInfoEntity).insert(entry);
  }

  // 更新数据库的宠物信息
  Future<int> updatePetInfo(PetInfo petInfo) {
    return (_dbService.update(_dbService.petInfoEntity)
          ..where((t) => t.id.isValue(petInfo.id)))
        .write(
      PetInfoEntityCompanion(
        petName: drift.Value(petInfo.petName),
        masterName: drift.Value(petInfo.masterName),
        petYear: drift.Value(petInfo.petYear),
        petMonth: drift.Value(petInfo.petMonth),
        phone: drift.Value(petInfo.phone),
        petWeight: drift.Value(petInfo.petWeight),
        petSex: drift.Value(petInfo.petSex),
        petType: drift.Value(petInfo.petType),
        simpleType: drift.Value(petInfo.simpleType),
        barCode: drift.Value(petInfo.barCode),
        otherOne: drift.Value(petInfo.otherOne),
        otherTwo: drift.Value(petInfo.otherTwo),
      ),
    );
  }

  //根据蓝牙mac地址查询手持机信息
  SingleOrNullSelectable<MyPalmF> getMyDeviceByMac(String mac) {
    return _dbService.select(_dbService.myPalmFEntity)
      ..where((tbl) {
        return tbl.mac.equals(mac);
      });
  }

  // 添加手持机蓝牙信息缓存到数据库
  Future<int> addMyDevice(MyPalmFEntityCompanion entry) {
    return _dbService.into(_dbService.myPalmFEntity).insert(entry);
  }

  // 更新数据库的code
  Future<int> updateCode(String mac, String code) {
    return (_dbService.update(_dbService.myPalmFEntity)
          ..where((t) => t.mac.isValue(mac)))
        .write(
      MyPalmFEntityCompanion(
        code: drift.Value(code),
      ),
    );
  }

  // 根据蓝牙地址删除手持机信息
  Future<int> removeMyPalmF(MyPalmFEntityCompanion entry) {
    return (_dbService.delete(_dbService.myPalmFEntity)
          ..where((e) {
            return (e.mac.isValue(entry.mac.value) &
                e.type.isValue(entry.type.value));
          }))
        .go();
  }

  // 根据设备类型地址删除PC蓝牙信息 设备类型 0 手持机 1 PC
  Future<int> removePC() {
    return (_dbService.delete(_dbService.myPalmFEntity)
          ..where((e) => e.type.isValue(1)))
        .go();
  }

  //删除所有历史数据
  Future<int> removeAllHistory() {
    return (_dbService.delete(_dbService.resultEntity)).go();
  }

  // 添加测试结果
  Future<int> addResult(ResultEntityCompanion entry) {
    MyLogUtil().i("$entry");

    return _dbService.into(_dbService.resultEntity).insert(entry);
  }

  // 查询没有上传网络的记录
  Future<List<Results>> queryResultUnUpload() {
    return (_dbService.select(_dbService.resultEntity)
          ..where((e) {
            return e.upload.isNotValue(true);
          }))
        .get();
  }

  // 根据MAC查询记录未上传成功的测试记录
  Future<List<Results>> queryResultByMac(String mac) {
    return (_dbService.select(_dbService.resultEntity)
          ..where((e) {
            return e.upload.isNotValue(true) & e.mac.isValue(mac);
          }))
        .get();
  }

  // 查询没有重复的测试结果记录
  Future<List<Results>> queryResultTheSame(
      String mac,
      double result,
      int saveNum,
      String resultDisplay,
      String projectName,
      int patientId,
      DateTime lastSyncTime) {
    String source = result.toStringAsFixed(saveNum ?? 0);
    double resultCal = double.parse(source);
    return (_dbService.select(_dbService.resultEntity)
          ..where((e) {
            return e.mac.isValue(mac) &
                (e.result.isValue(result) | e.result.isValue(resultCal)) &
                e.resultDisplay.contains(resultDisplay
                    .replaceAll(" ", "")
                    .replaceAll('\u0000', '')) &
                e.projectName.contains(
                    projectName.replaceAll(" ", "").replaceAll('\u0000', '')) &
                e.patientId.isValue(patientId);
          }))
        .get();
  }

  // 根据MAC地址和患者编号查询记录
  Future<List<Results>> queryResultByMacAndPatientId(String mac) {
    return (_dbService.select(_dbService.resultEntity)
          ..where((e) {
            return e.mac.isValue(mac);
          }))
        .get();
  }

  // 查询所有测试结果记录
  Future<List<Results>> allResultDataByPage(int pageSize, int pageNum,
      String projectName, String startTime, String endTime) {
    return (_dbService.select(_dbService.resultEntity)
          ..orderBy([
            (u) => OrderingTerm(expression: u.time, mode: OrderingMode.desc)
          ])
          ..limit(pageSize, offset: pageSize * pageNum)
          ..where((tbl) {
            if (startTime != "" && endTime != "") {
              return tbl.projectName.like('%$projectName%') &
                  tbl.time.isBiggerOrEqualValue(
                      DateTime.parse("$startTime 00:00:00")) &
                  tbl.time.isSmallerOrEqualValue(
                      DateTime.parse("$endTime 23:59:59"));
            } else {
              return tbl.projectName.like('%$projectName%');
            }
          }))
        .get();
  }

  // 查询所有测试结果记录条数
  Future<int> get allResultDataCount {
    return _dbService
        .select(_dbService.resultEntity)
        .get()
        .then((value) => value.length);
  }

  // 根据ID删除测试结果记录
  Future<int> deleteHistoryRecordById(int id) {
    return (_dbService.delete(_dbService.resultEntity)
          ..where((e) {
            return (e.id.isValue(id));
          }))
        .go();
  }

  // 更新结果上传状态
  Future<int> updateResultUpload(int id) {
    return (_dbService.update(_dbService.resultEntity)
          ..where((t) => t.id.isValue(id)))
        .write(
      const ResultEntityCompanion(
        upload: drift.Value(true),
      ),
    );
  }

  // 更新结果信息的最后同步时间
  Future<int> updateResultLastSyncTime(DateTime dateTime, String mac) {
    return (_dbService.update(_dbService.resultEntity)
          ..where((t) => t.mac.isValue(mac)))
        .write(
      ResultEntityCompanion(
        lastSyncTime: drift.Value(dateTime),
      ),
    );
  }

  // 添加手持机所有项目信息
  Future<int> addProject(ProjectParamsEntityCompanion entry) {
    return _dbService.into(_dbService.projectParamsEntity).insert(entry);
  }

  //删除手持机所有项目信息
  Future<int> removeAllProject() {
    return (_dbService.delete(_dbService.projectParamsEntity)).go();
  }

  // 根据项目名称查询项目
  Future<List<ProjectParams>> queryProjectNum() {
    return _dbService.select(_dbService.projectParamsEntity).get();
  }

  // 根据项目名称查询项目
  SingleOrNullSelectable<ProjectParams> queryProjectByName(String project) {
    return _dbService.select(_dbService.projectParamsEntity)
      ..where((tbl) {
        return tbl.projectShow.upper().equals(project.toUpperCase().trim()) |
            tbl.projectShow.lower().equals(project.toLowerCase().trim());
      });
  }

// // 监听所有的指定 category 的 todo 实体。
// // 如果底层数据修改，这个流会自动发出新的项目，即跟着底层数据实时更新。
// Stream<List<MyPalmF>> watchEntriesInCategory(Category c) {
// return (_dbService.select(_dbService.myPalmFEntity)..where((t) => t.category.equals(c.id))).watch();
// }
}
